use std::fs::{self, File,OpenOptions};
use std::io::{BufWriter, Read, Seek, SeekFrom, Write};
use std::path::Path;
use serde::{Deserialize,Serialize};
use serde_json::{Value};

pub mod chat_tool {
    use super::*; // 关键：引入父模块的可见项
    use base64::Engine;
    //检查是否有log,user,others文件与images文件夹，没有就添加
    pub fn exist_file(base_path: &str) -> Result<String, String> {
        let base = Path::new(base_path);
        let mut messages = Vec::new();

        // 处理 log.txt 文件（添加 ::std 确保路径解析）
        let log_path = base.join("log.txt");
        match ::std::fs::metadata(&log_path) { // 使用绝对路径
            Ok(metadata) => {
                if metadata.is_file() {
                    messages.push("log.txt 已存在".to_string());
                } else {
                    return Err(format!("'{}' 已存在但不是文件", log_path.display()));
                }
            }
            Err(_) => {
                File::create(&log_path)
                    .map_err(|e| format!("创建文件失败: {}", e))?
                    .write_all(b"[]")
                    .map_err(|e| format!("写入文件失败: {}", e))?;
                messages.push("log.txt 已创建".to_string());
            }
        }

        // 处理 images 目录
        let images_dir = base.join("images");
        match fs::metadata(&images_dir) { // 这里可以用相对路径因为已经 use super::*
            Ok(metadata) => {
                if metadata.is_dir() {
                    messages.push("images 目录已存在".to_string());
                } else {
                    return Err(format!("'{}' 已存在但不是目录", images_dir.display()));
                }
            }
            Err(_) => {
                fs::create_dir(&images_dir)
                    .map_err(|e| format!("创建目录失败: {}", e))?;
                messages.push("images 目录已创建".to_string());
            }
        }

        Ok(messages.join("\n"))
    }
   
    #[derive(Debug, Deserialize)]
    struct ImageInfo {
        name: String,
        file: String,  // base64编码的图片数据
        imgtype: String,
    }
   //保存图片到images文件夹中
    pub fn save_image(
        base_path: &str,
        image_info_str: &str,
    ) -> Result<String, String> {
        let base = Path::new(base_path);
 
        // 解析JSON
        let image_info: ImageInfo = serde_json::from_str(image_info_str)
            .map_err(|e| format!("JSON解析失败: {}", e))?;
        // 验证图片格式
        let imgtype_lower = image_info.imgtype.to_lowercase();
        let allowed_types = ["png", "jpg", "jpeg", "gif", "webp"];
        if !allowed_types.contains(&&*imgtype_lower) {
            return Err(format!("不支持的图片格式: {}", image_info.imgtype));
        }

        // 构建保存路径
        let image_dir = base.join("images");
        let filename = format!("{}.{}", image_info.name, imgtype_lower);
        let image_path = image_dir.join(&filename);

        // 解码base64
        let bytes = base64::engine::general_purpose::STANDARD
            .decode(&image_info.file)
            .map_err(|e| format!("Base64解码失败: {}", e))?;

        // 写入文件
        fs::write(&image_path, &bytes)
            .map_err(|e| format!("文件写入失败: {}", e))?;

        Ok(format!("图片保存成功: {}", filename))
    }
    //为log.txt追加内容
    pub fn log_data(base_path: &str, json_str: &str) -> Result<String, String> {
        let log_path = Path::new(base_path).join("log.txt");
    
        // 解析输入JSON（保持原校验逻辑）
        let new_entry: serde_json::Value = serde_json::from_str(json_str)
            .map_err(|e| format!("无效JSON输入: {}", e))?;
    
        // 原子写入优化（解决数据丢失 + 性能问题）
        atomic_append(&log_path, &new_entry)?;
    
        Ok("日志记录成功".to_string())
    }
    
    /// 创建临时文件，写如临时文件，成功则替换
    fn atomic_append(path: &Path, entry: &serde_json::Value) -> Result<(), String> {
        // 步骤1：创建临时文件
        let temp_path = path.with_extension("tmp");
        let mut temp_file = OpenOptions::new()
            .write(true)
            .create(true)
            .open(&temp_path)
            .map_err(|e| format!("临时文件创建失败: {}", e))?;
    
        // 步骤2：复制原文件内容到临时文件
        if path.exists() {
            let mut src_file = File::open(path)
                .map_err(|e| format!("原文件打开失败: {}", e))?;
            let mut buffer = Vec::new();
            src_file.read_to_end(&mut buffer)
                .map_err(|e| format!("原文件读取失败: {}", e))?;
            temp_file.write_all(&buffer)
                .map_err(|e| format!("临时文件写入失败: {}", e))?;
        }
 
        // 步骤3：追加新条目到临时文件
        let writer = BufWriter::new(&mut temp_file);
        append_json_entry(writer, entry, path.exists())?;
    
        // 步骤4：原子替换文件
        std::fs::rename(&temp_path, path)
            .map_err(|e| format!("文件替换失败: {}", e))?;
    
        Ok(())
    }
    
    //写入文件末尾{}
    fn append_json_entry(
        mut writer: impl Write + Seek,
        entry: &serde_json::Value,
        is_existing: bool
    ) -> Result<(), String> {
        // 处理不同写入场景
        if !is_existing {
            // 新文件：写入完整数组结构
            write!(writer, "[\n")
                .map_err(|e| format!("初始写入失败: {}", e))?;
        } else {
                    // 已有文件：定位到倒数第2字节（覆盖最后的']'）
    
            let file_size = writer.seek(SeekFrom::End(0))
            .map_err(|e| format!("获取文件大小失败: {}", e))?;
     
        if file_size != 2{
            writer.seek(SeekFrom::End(-1))
            .map_err(|e| format!("文件定位失败: {}", e))?;
            write!(writer, ",\n") // 追加逗号分隔符
            .map_err(|e| format!("分隔符写入失败: {}", e))?;
        }
    else{
        writer.seek(SeekFrom::End(-1))
        .map_err(|e| format!("文件定位失败: {}", e))?;
        write!(writer, "\n\n") // 追加逗号分隔符
    .map_err(|e| format!("分隔符写入失败: {}", e))?;
    }
       
        }

        // 写入新条e目
        serde_json::to_writer_pretty(&mut writer, entry)
            .map_err(|e| format!("条目序列化失败: {}", e))?;
    
        // 闭合数组
        write!(writer, "\n]")
            .map_err(|e| format!("闭合符写入失败: {}", e))?;
    
        Ok(())
    }
    //判断传递的内容是否为image,type
    pub fn process_input(input: &str,scoped_type:&str,base_path: &str) -> Result<String, String> {
        // 解析 JSON 字符串为动态 Value 类型
        let mut json: Value = serde_json::from_str(input)
            .map_err(|e| format!("JSON解析失败: {}", e))?;
    
        // 检查 type 字段是否存在且为字符串
        let type_value = json.get("type")
            .ok_or("缺少 'type' 字段".to_string())?
            .as_str()
            .ok_or("'type' 字段不是字符串类型".to_string())?;
    
        // 判断 type 值是否为 image
        if type_value == "image" {
            // 获取对象可变引用并删除 name 字段
            if let Some(obj) = json.as_object_mut() {
                obj.remove("file");
            }
            if scoped_type =="add"{
                match save_image(base_path,input){
                    Ok(success_msg) => {
                   
                        println!("添加图片{}",success_msg);
                        
                    },
                    Err(error_msg) => eprintln!("错误: {}", error_msg),    
                };
            }
        }
    
        // 将修改后的 JSON 序列化为字符串
        serde_json::to_string(&json)
            .map_err(|e| format!("JSON序列化失败: {}", e))
    }
    pub fn delete_log_entry(
        base_path: &str,
        query_json: &str,
    ) -> Result<String, String> {
        let base = Path::new(base_path);
        let log_path = base.join("log.txt");

        // 解析查询参数
        let query: Value = serde_json::from_str(query_json)
            .map_err(|e| format!("无效查询JSON: {}", e))?;
  
        let target_name = query.get("name")
            .and_then(|v| v.as_str())
            .ok_or("查询JSON缺少name字段或类型错误".to_string())?;
     
        // 读取并解析日志文件
        let contents = std::fs::read_to_string(&log_path)
            .map_err(|e| format!("文件读取失败: {}", e))?;

        let mut json_array: Vec<Value> = if contents.trim().is_empty() {
            return Err("日志文件为空".to_string());
        } else {
            serde_json::from_str(&contents)
                .map_err(|e| format!("日志解析失败: {}", e))?
        };

        // 过滤条目
        let original_len: usize = json_array.len();
        json_array.retain(|entry| {
            entry.get("name")
                .and_then(|v| v.as_str())
                .map(|name| name != target_name)
                .unwrap_or(true)
        });

        if original_len == json_array.len() {
            return Err(format!("未找到name为'{}'的条目", target_name));
        }

        // 原子替换流程
        let temp_path = log_path.with_extension("tmp");
        // 创建临时文件并写入新内容
        let new_contents = serde_json::to_string_pretty(&json_array)
            .map_err(|e| format!("JSON序列化失败: {}", e))?;
        std::fs::write(&temp_path, &new_contents)
            .map_err(|e| format!("临时文件写入失败: {}", e))?;
    
        // 原子替换原文件
        std::fs::rename(&temp_path, &log_path)
            .map_err(|e| format!("文件替换失败: {}", e))?;
    
        Ok(format!("成功删除{}条记录", original_len - json_array.len()))
    }
    #[derive(Debug, Deserialize)]
    struct DeleteRequest {
        name: String,
        imgtype: String,
    }
    //删除图片
    pub fn delete_image(
        base_path: &str,
        request_json: &str,
    ) -> Result<String, String> {
        let base = Path::new(base_path);
        
        // 解析JSON请求
        let request: DeleteRequest = serde_json::from_str(request_json)
            .map_err(|e| format!("JSON解析失败: {}", e))?;

        // 验证图片类型格式
        let imgtype_lower = request.imgtype.to_lowercase();
        let allowed_types = ["png", "jpg", "jpeg", "gif", "webp"];
        if !allowed_types.contains(&&*imgtype_lower) {
            return Err(format!("无效的图片类型: {}", request.imgtype));
        }

        // 构建文件路径
        let images_dir = base.join("images");
        let filename = format!("{}.{}", request.name, imgtype_lower);
        let file_path = images_dir.join(&filename);

        // 检查文件是否存在
        if !file_path.exists() {
            return Err(format!("文件不存在: {}", filename));
        }

        // 删除文件
        fs::remove_file(&file_path)
            .map_err(|e| format!("删除失败: {}", e))?;

        Ok(format!("成功删除文件: {}", filename))
    }
    #[derive(Serialize)]
    struct ImageData {
        name: String,
        imgtype: String,
        data: String, // base64编码
    }

    #[derive(Serialize)]
    #[serde(rename_all = "camelCase")]
    pub struct DataResponse {
        log: serde_json::Value,
        images: Vec<ImageData>,
    }
   //获取log.txt中的对象，获取images文件夹中的全部文件
    pub fn get_all_data(base_path: &str) -> Result<DataResponse, String> {
        let base = Path::new(base_path);
        let log_path = base.join("log.txt");
        println!("日子{}",log_path.display());
        // 处理日志文件
        let log_content = fs::read_to_string(log_path)
            .map_err(|e| format!("日志读取失败: {}", e))?;
      
//         let bytes = fs::read(log_path)?;

// // 检测并移除无效的 BOM 头（前2字节）
//         let (normalized_content, _, has_bom) = UTF_16LE.decode(&bytes[2..]); // 跳过前2字节
        let log_json: serde_json::Value = serde_json::from_str(&log_content)
        .map_err(|e| {
            format!(
                "日志解析失败: {} (位置: 行 {} 列 {})",
                e,
                e.line(),
                e.column()
            )
        })?;
        // 处理图片文件
        let mut images = Vec::new();
        let images_dir = base.join("images");

        if let Ok(entries) = fs::read_dir(images_dir) {
            for entry in entries.flatten() {
                let path = entry.path();
                if path.is_file() {
                    let filename = path.file_stem()
                        .and_then(|n| n.to_str())
                        .unwrap_or_default()
                        .to_string();

                    let ext = path.extension()
                        .and_then(|e| e.to_str())
                        .unwrap_or("unknown")
                        .to_lowercase();

                    let file_data = fs::read(&path)
                        .map_err(|e| format!("文件读取失败: {}", e))?;

                    images.push(ImageData {
                        name: filename,
                        imgtype: ext,
                 
                        data: base64::engine::general_purpose::STANDARD.encode(&file_data),
                    });
                }
            }
        }

        Ok(DataResponse {
            log: log_json,
            images,
        })
    }
}